Day 21 Spies 間諜來襲！

13th鐵人賽

Robert Chang

2021-10-05 18:25:26

869 瀏覽

分享至

該文章同步發佈於：我的部落格

也歡迎關注我的 Facebook 以及 Instagram 接收軟體相關的資訊！

今天我們要介紹 Mock 軍團的最後一員，也就是 Spies 這個用法！

除了加上範例之外，兩者間的差別，也會好好地來解釋一番～

和 double 的差別

首先就是 Spies 本身更狡詐了一些，還記得我們在寫 double 或是 instance double 的時候，常常要在先去期望這個變數獲得什麼樣的方法，並寫在他的後面～

像是這樣：

RSpec.describe 'double' do
  let(:store) { double('store', sell: 'earn the money!')}
  
  it 'should invoke method first' do
    expect(store.sell).to eq('earn the money!')
  end
end

但 Spies 本身是可以先寫方法出來的，就像正常的測試一樣，只是 expectation 的部分需要做一些改造！

像是這樣：

RSpec.describe 'spies' do
  let(:burger) { spy('burger') }
  
  it 'confirm a message has been received' do
    burger.eat
    expect(burger).to have_received(:eat)
  end
end

其實有趣的地方在於，這邊的 expectation 是 have_received，有種在玩英文文法的感覺，這個漢堡已經接收到 eat 方法的概念！

而 Spies 也有他的檢查機制存在，若是我們沒有收到的方法，但卻有的話會發生什麼事呢？

RSpec.describe 'spies' do
  let(:burger) { spy('burger') }
  
  it 'confirm a message has been received' do
    burger.eat
    expect(burger).to have_received(:eat)
    expect(burger).to have_received(:throw)
  end
end

這個變數期待著一次的 throw 方法，但卻沒有，所以被噴錯了。

那至於這個和 instance double 之間要如何做選擇呢？這邊先賣個關子，後面會有有趣的實驗來看看差別在哪裡～

使用情境

其實使用的情境和 instance double 基本上是很像的，都是為了獨立某段程式碼的干擾，讓測試的獨立性更好，更專注在我們要測試的部分。

而不是為了生出別的實體變數而搞得滿目瘡痍～

這邊再用一段簡單的程式碼來敘述一下情境！

class Cheese
  def initialize(type)
    @type = type
  end
end

class Burger
  attr_reader :cheese
  
  def initialize
    @cheese = []
  end
  
  def add(type)
    @cheese << Cheese.new(type)
  end
end

這邊很清晰的是我們要在漢堡裡面加入 cheese ，就像前幾天談到的一樣，我們要專注在 Burger 這個類別，所以我們希望可以把第 15 行的 Cheese.new(type) 這段給獨立出來，用 mock 的方式替代！

接著我們來寫會通過的測試！

RSpec.describe Burger do
  let(:cheese) { spy(Cheese) }
  
  before do
    allow(Cheese).to receive(:new).and_return(cheese)
  end
  
  describe '#add' do
    it 'add cheese to burger' do
      subject.add('parmesan')
      expect(Cheese).to have_received(:new).with('parmesan')
      expect(subject.cheese.length).to eq 1
      expect(subject.cheese.first).to eq(cheese)
    end
  end
end

我們逐行來解釋一下，首先在進入測試之前( 第五行 )，我們先做了允許 Cheese 這個類別接收 new 方法，並且 return 我們的 spy(Cheese)

接著進入測試的 block 中，subject 執行了 add 方法，並且傳入參數 parmesan。

接著我們又說這個 Cheese 已經接受了 new 方法，也就是我們在 before block 中所做的事情，在這個時候，我們已經徹底的替換掉正式的程式碼了。

接著的 expectation 就是基本的操作囉～

但你會發現，這個 spy 替換成 instance_double 也能夠正常的使用。

奇怪了... 那我們印出來看看吧！我們先印印看 spy 版本的

RSpec.describe Burger do
  let(:cheese) { spy(Cheese) }
  
  before do
    allow(Cheese).to receive(:new).and_return(cheese)
  end
  
  describe '#add' do
    it 'add cheese to burger' do
      subject.add('parmesan')
      expect(Cheese).to have_received(:new).with('parmesan')
      p cheese # 印出來看看吧
      expect(subject.cheese.length).to eq 1
      expect(subject.cheese.first).to eq(cheese)
    end
  end
end

有沒有搞錯？這個 spies 講得這麼厲害，但結果是 double 的語法糖衣嗎？

我們快印看看 instance double 是什麼？

RSpec.describe Burger do
  let(:cheese) { instance_double(Cheese) }
  
  before do
    allow(Cheese).to receive(:new).and_return(cheese)
  end
  
  describe '#add' do
    it 'add cheese to burger' do
      subject.add('parmesan')
      expect(Cheese).to have_received(:new).with('parmesan')
      p cheese # 印出來看看吧
      expect(subject.cheese.length).to eq 1
      expect(subject.cheese.first).to eq(cheese)
    end
  end
end